
package principal;


import Cliente.ThreadCliente;
import datos.*;
import interfaz.VentanaPrincipal;
import java.io.*;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import ListaHash.*;

public class Cliente extends Thread
{
    private Jugador jugador;
    private Socket sockcliente;
    private VentanaPrincipal tablero;
    private boolean terminado;
    private boolean comenzar;
    public static String IP_SERVER;
    
    private DataInputStream entrada = null;
    private DataOutputStream salida = null;
    private DataInputStream entrada2 = null;
    private Socket comunication = null;//para la comunicacion
    private Socket comunication2 = null;//para recivir msg
    private Pais[] paises;
    private Objetivo mision;
    private HashTable mundo;
    private ArrayList paisesPropios;

    public Cliente(VentanaPrincipal tablero, Jugador jugador, String ipServer) {
        this.jugador = jugador;
        this.tablero = tablero;
        this.terminado = false;
        this.comenzar = false;
        paisesPropios=new ArrayList();
        mundo = new HashTable<Pais>();
        IP_SERVER = ipServer; //HAY Q CAMBIAR ESTO!!!
    }

    public Jugador getJugador() {
        return jugador;
    }

    public Objetivo getMision() {
        return mision;
    }

    public void setMision(Objetivo mision) {
        this.mision = mision;
    }

    public void setComenzar(boolean comenzar) {
        this.comenzar = comenzar;
    }

    public void setTerminado(boolean terminado) {
        this.terminado = terminado;
    }

    @Override
    public void run(){
        try {
            this.conexion();
        } catch (IOException ex) {
            tablero.actualizarChat("\n   El servidor no esta levantado");
            tablero.actualizarChat("\n   =============================\n\n");
        }
    }

    public void conexion() throws IOException
   {
        comunication = new Socket(Cliente.IP_SERVER, 8081);
        comunication2 = new Socket(Cliente.IP_SERVER, 8082);
        entrada = new DataInputStream(comunication.getInputStream());
        salida = new DataOutputStream(comunication.getOutputStream());
        entrada2 = new DataInputStream(comunication2.getInputStream());

        salida.writeUTF(jugador.getNombre());
        tablero.actualizarChat("\nConectado!!!\n\n");

        new ThreadCliente(this, entrada2, tablero).start();
   }

   public Vector<String> pedirUsuarios()
   {
      Vector<String> users = new Vector();
      try {         
         salida.writeInt(2);
         int numUsers=entrada.readInt();
         for(int i=0;i<numUsers;i++)
            users.add(entrada.readUTF());
      } catch (IOException ex) {
         Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
      }
      return users;
   }
   
   public void flujo(String mens) 
   {
      try {             
         salida.writeInt(1);
         salida.writeUTF(mens);
      } catch (IOException e) {
         System.out.println("error...." + e);
      }
   }
   
   public void flujo(String amigo,String mens) 
   {
      try {             
         salida.writeInt(3);//opcion de mensage a amigo
         salida.writeUTF(amigo);
         salida.writeUTF(mens);
      } catch (IOException e) {
         System.out.println("error...." + e);
      }
   }

    public String[] traeNombresYColores() {
        String[] nombresColores = null;
        try {
            salida.writeInt(9);
            int cantUsuarios = entrada.readInt();
            nombresColores = new String[cantUsuarios*2];
            for(int i=0;i<nombresColores.length;i++)
                nombresColores[i] = entrada.readUTF();
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
        return nombresColores;
    }
    
    public void actualizarColor(String nombre, String color) {
        try {         
            salida.writeInt(10);
            salida.writeUTF(nombre);
            salida.writeUTF(color);
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void avisarColores() {
        try {         
            salida.writeInt(11);//avisar colores
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void avisarComenzarPartida() {
        try {         
            salida.writeInt(12);//avisar comenzar partida
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void gestionarJuego() 
    {
        try {         
            salida.writeInt(13);//avisar gestionar juego
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public void actualizarPais(String color,String pais, int a)
    {   
         setTropaAPais(pais, a, color);
         tablero.actualizarPais(color, pais, a);
    }
    public void modificarTurnos(String[] nombreJugadores, String[] coloresJugadores)
    {
        tablero.modificarTurnos(nombreJugadores, coloresJugadores);
    }
    
    public void crearMundo() 
    {
        //creo el mundo 

    
    //empiezo creando los simbolos
    Simbolo caballo=new Simbolo("caballo", "no se");
    Simbolo cañon=new Simbolo("cañon", "no se");
    Simbolo infanteria=new Simbolo("infanteria", "no se");
    Simbolo comodin=new Simbolo("comodin", "no se");
    
    //creo los contientes
    Continente norteAmerica= new Continente(10, 0, "AMERICA DEL NORTE");
    Continente sudAmerica= new Continente(6, 0, "AMERICA DEL SUR");
    Continente africa= new Continente(6, 0, "AFRICA");
    Continente europa= new Continente(9, 0, "EUROPA");
    Continente asia= new Continente(15, 0, "ASIA");
    Continente oceania= new Continente(4, 0, "OCEANIA");
    
    //creo los paises
    Pais Francia=new Pais(europa, "Francia" );
    Pais Rusia=new Pais(europa, "Rusia");
    Pais Italia=new Pais(europa, "Italia");
    Pais Espania=new Pais(europa, "Espania");
    Pais Islandia=new Pais(europa, "Islandia");
    Pais GranBretania=new Pais(europa, "GranBretania");
    Pais Alemania=new Pais(europa, "Alemania");
    Pais Polonia=new Pais(europa, "Polonia");
    Pais Suecia=new Pais(europa, "Suecia");
    Pais Siberia=new Pais(asia, "Siberia");
    Pais Tartaria=new Pais(asia, "Tartaria");
    Pais Japon=new Pais(asia, "Japon");
    Pais Mongolia=new Pais(asia, "Mongolia");
    Pais Taimir=new Pais(asia, "Taimir");
    Pais Aral=new Pais(asia, "Aral");
    Pais Gobi=new Pais(asia, "Gobi");
    Pais Iran=new Pais(asia, "Iran");
    Pais Turquia=new Pais(asia, "Turquia");
    Pais Israel=new Pais(asia, "Israel");
    Pais Arabia=new Pais(asia, "Arabia");
    Pais Katchatka=new Pais(asia, "Katchatka");
    Pais China=new Pais(asia, "China" );
    Pais India=new Pais(asia, "India");
    Pais Malasia=new Pais(asia, "Malasia");
    Pais Java=new Pais(oceania, "Java");
    Pais Sumatra=new Pais(oceania, "Sumatra");
    Pais Borneo=new Pais(oceania, "Borneo");
    Pais Australia=new Pais(oceania, "Australia");
    Pais Zaire= new Pais(africa, "Zaire");
    Pais Sudafrica=new Pais(africa, "Sudafrica");
    Pais Madagascar= new Pais(africa, "Madagascar");
    Pais Etiopia=new Pais(africa, "Etiopia");
    Pais Egipto= new Pais(africa, "Egipto");
    Pais Sahara=new Pais(africa, "Sahara");
    Pais Peru=new Pais(sudAmerica, "Peru");
    Pais Chile=new Pais(sudAmerica, "Chile");
    Pais Uruguay=new Pais(sudAmerica, "Uruguay");
    Pais Colombia= new Pais(sudAmerica, "Colombia");
    Pais Terranova= new Pais(norteAmerica, "Terranova");
    Pais Oregon=new Pais(norteAmerica, "Oregon");
    Pais NuevaYork=new Pais(norteAmerica, "NuevaYork");
    Pais Mexico=new Pais(norteAmerica, "Mexico");
    Pais Labrador=new Pais(norteAmerica, "Labrador");
    Pais Groenlandia=new Pais(norteAmerica, "Groenlandia");
    Pais Canada=new Pais(norteAmerica, "Canada");
    Pais California=new Pais(norteAmerica, "California");   
    Pais Brasil=new Pais(sudAmerica, "Brasil");
    Pais Alaska=new Pais(norteAmerica, "Alaska");
    Pais Yukon=new Pais(norteAmerica, "Yukon");
    Pais Argentina= new Pais(sudAmerica, "Argentina");
            
    //asignar limitrofes
    
    Argentina.agregarLimitrofe(Chile);
    Argentina.agregarLimitrofe(Brasil);
    Argentina.agregarLimitrofe(Uruguay);
    Argentina.agregarLimitrofe(Peru);
    
    Chile.agregarLimitrofe(Peru);
    Chile.agregarLimitrofe(Australia);
    
    Uruguay.agregarLimitrofe(Brasil);
    
    Brasil.agregarLimitrofe(Peru);
    Brasil.agregarLimitrofe(Colombia);
    Brasil.agregarLimitrofe(Sahara);
    
    Peru.agregarLimitrofe(Colombia);
    
    Colombia.agregarLimitrofe(Mexico);
    
    Mexico.agregarLimitrofe(California);
    
    California.agregarLimitrofe(Oregon);
    California.agregarLimitrofe(NuevaYork);
    
    Oregon.agregarLimitrofe(NuevaYork);
    Oregon.agregarLimitrofe(Yukon);
    Oregon.agregarLimitrofe(Alaska);
    Oregon.agregarLimitrofe(Canada);
    
    Alaska.agregarLimitrofe(Yukon);
    Alaska.agregarLimitrofe(Katchatka);
    
    Yukon.agregarLimitrofe(Canada);
    
    Canada.agregarLimitrofe(NuevaYork);
    Canada.agregarLimitrofe(Terranova);
    
    NuevaYork.agregarLimitrofe(Terranova);
    
    Terranova.agregarLimitrofe(Labrador);
    
    Labrador.agregarLimitrofe(Groenlandia);
    
    Groenlandia.agregarLimitrofe(Islandia);
    Groenlandia.agregarLimitrofe(NuevaYork);
    
    Islandia.agregarLimitrofe(Suecia);
    Islandia.agregarLimitrofe(GranBretania);
    
    GranBretania.agregarLimitrofe(Alemania);
    GranBretania.agregarLimitrofe(Espania);
    
    Espania.agregarLimitrofe(Francia);
    Espania.agregarLimitrofe(Sahara);
    
    Francia.agregarLimitrofe(Italia);
    Francia.agregarLimitrofe(Alemania);
    
    Italia.agregarLimitrofe(Alemania);
    
    Alemania.agregarLimitrofe(Polonia);
    
    Polonia.agregarLimitrofe(Egipto);
    Polonia.agregarLimitrofe(Rusia);
    Polonia.agregarLimitrofe(Turquia);
    
    Rusia.agregarLimitrofe(Suecia);
    Rusia.agregarLimitrofe(Aral);
    Rusia.agregarLimitrofe(Iran);
    
    Sahara.agregarLimitrofe(Egipto);
    Sahara.agregarLimitrofe(Etiopia);
    Sahara.agregarLimitrofe(Zaire);
    
    Zaire.agregarLimitrofe(Etiopia);
    Zaire.agregarLimitrofe(Sudafrica);
    Zaire.agregarLimitrofe(Madagascar);
    
    Sudafrica.agregarLimitrofe(Etiopia);
    
    Etiopia.agregarLimitrofe(Egipto);
    
    Egipto.agregarLimitrofe(Madagascar);
    Egipto.agregarLimitrofe(Israel);
    Egipto.agregarLimitrofe(Turquia);
    
    Australia.agregarLimitrofe(Java);
    Australia.agregarLimitrofe(Sumatra);
    Australia.agregarLimitrofe(Borneo);
    
    Java.agregarLimitrofe(Sumatra);
    
    Borneo.agregarLimitrofe(Malasia);
    
    Sumatra.agregarLimitrofe(India);
    
    Malasia.agregarLimitrofe(China);
    Malasia.agregarLimitrofe(India);
    
    India.agregarLimitrofe(China);
    India.agregarLimitrofe(Iran);
    
    Israel.agregarLimitrofe(Turquia);
    Israel.agregarLimitrofe(Arabia);
    
    Turquia.agregarLimitrofe(Arabia);
    Turquia.agregarLimitrofe(Iran);
    
    Iran.agregarLimitrofe(China);
    Iran.agregarLimitrofe(Gobi);
    Iran.agregarLimitrofe(Mongolia);
    Iran.agregarLimitrofe(Aral);
    
    Gobi.agregarLimitrofe(Mongolia);
    Gobi.agregarLimitrofe(China);
    
    China.agregarLimitrofe(Mongolia);
    China.agregarLimitrofe(Siberia);
    China.agregarLimitrofe(Katchatka);
    China.agregarLimitrofe(Japon);
    
    Japon.agregarLimitrofe(Katchatka);
    
    Katchatka.agregarLimitrofe(Siberia);
    
    Mongolia.agregarLimitrofe(Siberia);
    Mongolia.agregarLimitrofe(Aral);
    
    Aral.agregarLimitrofe(Tartaria);
    Aral.agregarLimitrofe(Siberia);
    
    Tartaria.agregarLimitrofe(Siberia);
    Tartaria.agregarLimitrofe(Taimir);
    
    Taimir.agregarLimitrofe(Siberia);
      
     paises= new Pais[50];
    
    //agrego paises al arreglo
 
     
    paises[0]=Francia;
    paises[1]=Rusia;
    paises[2]=Italia;
    paises[3]=Espania;
    paises[4]=Islandia;
    paises[5]=GranBretania;
    paises[6]=Alemania;
    paises[7]=Polonia;
    paises[8]=Suecia;
    paises[9]=Siberia;
    paises[10]=Tartaria;
    paises[11]=Japon;
    paises[12]=Mongolia;
    paises[13]=Taimir;
    paises[14]=Aral;
    paises[15]=Gobi;
    paises[16]=Iran;
    paises[17]=Turquia;
    paises[18]=Israel;
    paises[19]=Arabia;
    paises[20]=Katchatka;
    paises[21]=China;
    paises[22]=India;
    paises[23]=Malasia;
    paises[24]=Java;
    paises[25]=Sumatra;
    paises[26]=Borneo;
    paises[27]=Australia;
    paises[28]=Zaire;
    paises[29]=Sudafrica;
    paises[30]=Madagascar;
    paises[31]=Etiopia;
    paises[32]=Egipto;
    paises[33]=Sahara;
    paises[34]=Peru;
    paises[35]=Chile;
    paises[36]=Uruguay;
    paises[37]=Colombia;
    paises[38]=Terranova;
    paises[39]=Oregon;
    paises[40]=NuevaYork;
    paises[41]=Mexico;
    paises[42]=Labrador;
    paises[43]=Groenlandia;
    paises[44]=Canada;
    paises[45]=California;
    paises[46]=Brasil ;
    paises[47]=Alaska;
    paises[48]=Yukon;
    paises[49]=Argentina;
    
    
    //asignar simbolos
  
    Simbolo aux[]=new Simbolo[4];
    aux[0]=caballo;
    aux[1]=cañon;
    aux[2]=comodin;
    aux[3]=infanteria;
    int numeroOrden=0;
    for(int i=0; i<50; i++)
    {
        Pais auxPais=paises[i];
        auxPais.agregarSimbolo(aux[numeroOrden]);
        numeroOrden=numeroOrden+1;
        if(numeroOrden==4)
        {
            numeroOrden=0;
        }
    }
    
     mundo.insertar(Francia);
     mundo.insertar(Rusia);
     mundo.insertar(Italia);
     mundo.insertar(Islandia);
     mundo.insertar(Espania);
     mundo.insertar(GranBretania);
     mundo.insertar(Alemania);
     mundo.insertar(Suecia);
     mundo.insertar(Polonia);
     mundo.insertar(Siberia);
     mundo.insertar(Tartaria);
     mundo.insertar(Japon);
     mundo.insertar(Mongolia);
     mundo.insertar(Taimir);
     mundo.insertar(Aral);
     mundo.insertar(Gobi);
     mundo.insertar(Iran);
     mundo.insertar(Turquia);
     mundo.insertar(Israel);
     mundo.insertar(Arabia);
     mundo.insertar(Katchatka);
     mundo.insertar(China);
     mundo.insertar(India);
     mundo.insertar(Malasia);
     mundo.insertar(Java);
     mundo.insertar(Sumatra);
     mundo.insertar(Borneo);
     mundo.insertar(Australia);
     mundo.insertar(Zaire);
     mundo.insertar(Sudafrica);
     mundo.insertar(Madagascar);
     mundo.insertar(Etiopia);
     mundo.insertar(Egipto);
     mundo.insertar(Sahara);
     mundo.insertar(Peru);
     mundo.insertar(Chile);
     mundo.insertar(Uruguay);
     mundo.insertar(Colombia);
     mundo.insertar(Terranova);
     mundo.insertar(Oregon);
     mundo.insertar(NuevaYork);
     mundo.insertar(Mexico);
     mundo.insertar(Labrador);
     mundo.insertar(Groenlandia);
     mundo.insertar(Canada);
     mundo.insertar(California);
     mundo.insertar(Brasil);
     mundo.insertar(Alaska);
     mundo.insertar(Yukon);
     mundo.insertar(Argentina);
    }

    public void crearMision(String desc, int norteAmerica, int sudAmerica, int europa, int asia, int africa, int oceania) 
    {
        mision= new Objetivo(desc, norteAmerica, sudAmerica, europa, asia, africa, oceania, null);
        tablero.crearMision(desc);
//        tablero.actualizarChat("\n Mision: "+desc);
    }
    public boolean verificarMision()
    {
        return mision.verificarObjetivo(paisesPropios, jugador.getColor());
    }

    public void actualizarAgregarTropas(String pais, String direccion, int ejercito) {
        try {
            salida.writeInt(14);//avisar actualizacion pais
            salida.writeUTF(pais);
            salida.writeUTF(direccion);
            salida.writeInt(ejercito);
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void avisarProximoTurno(int turno) {
        try {
            salida.writeInt(15);//avisar proximo turno
            salida.writeInt(turno);
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void comenzarNuevaRonda() {
        try {
            salida.writeInt(16);//comenzar nueva ronda
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public boolean verificarLimitrofes(String paisOrigen, String paisDestino) {
        Pais origen=(Pais)mundo.buscar(new Pais(paisOrigen, "", 0));
        Pais destino=(Pais)mundo.buscar(new Pais(paisDestino, "", 0));;
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(paisOrigen))
            {
                origen=paises[i];
            }
            if(paises[i].getNombre().equals(paisDestino))
            {
                 destino=paises[i];
            }
            
        }
        * */
        
        if(origen.esYaUnPaisLimitrofe(destino))
        {
            return true;
        }
        else
        {
            return false;
        }
        
    }

    public boolean verificarDistintosJugadores(String paisOrigen, String paisDestino) 
    {
        Pais origen=(Pais)mundo.buscar(new Pais(paisOrigen, "", 0));
        Pais destino=(Pais)mundo.buscar(new Pais(paisDestino, "", 0));
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(paisOrigen))
            {
                origen=paises[i];
            }
            if(paises[i].getNombre().equals(paisDestino))
            {
                 destino=paises[i];
            }
            
        }

        */
      if(jugador.getColor()==origen.getColor() && jugador.getColor()==destino.getColor())
      {
          return false;
      }
      else
      {
          return true;
      }
        
        
    }

//    public int calcularDados(String paisOrigen) //ver si se usa
//    {
//         for(int i=0; i<50; i++)
//        {
//            if(paises[i].getNombre().equals(paisOrigen))
//            {
//             return paises[i].getTropas();
//            }
//            
//        }
//         return -1;
//    }

    public void restaEjercito(String pais, int ejercito)   // Si se usa
    { 
        Pais aux=(Pais)mundo.buscar(new Pais(pais, "", 0));
        aux.setTropas( aux.getTropas()-ejercito);
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(pais))
            {
             paises[i].setTropas( paises[i].getTropas()-ejercito);
            }
            
        }
        */
    }
    
    public void restaEjercito(String pais) // no creo q haga falta el retador menos 1
    { 
        Pais aux=(Pais)mundo.buscar(new Pais(pais, "", 0));
        aux.setTropas( aux.getTropas()-1);
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(pais))
            {
             paises[i].setTropas( paises[i].getTropas()-1);
            }
        }*/
    }

//    public boolean verificarGanarPais(String pais) // esto se hace en la ventana
//    {
//          for(int i=0; i<50; i++)
//        {
//            if(paises[i].getNombre().equals(pais)&&paises[i].getTropas()==0)
//            {
//             return true;
//            }
//           
//            
//        }
//         return false;
//    }

    public void conquistarPais(String pais) {  // Si se usa
       Pais aux=(Pais)mundo.buscar(new Pais(pais, "", 0));
       aux.setColor(jugador.getColor());
       /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(pais))
            {
                paises[i].setColor(jugador.getColor());
//                paises[i].setTropas(1);       Xq todavia no se sabe cuanto ejercito se va a pasar
            }
        }*/
    }

    public int obtenerEjercitoDePais(String paisOrigen) {  //Buenisimo jeje
        //paises es un arreglo que tiene todos los paises.. de esta forma tengo
        //acceso a los ejercitos que tienen los paises y sus colores sin tiener
        //que ver el mapa
        Pais aux=(Pais)mundo.buscar(new Pais(paisOrigen, "", 0));
        return aux.getTropas();
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(paisOrigen))
            {
             return paises[i].getTropas();
            }
        }
        return -1;*/
    } 

    public String getColorDePais(String paisOrigen) //Si se usa
    {   Pais aux=(Pais)mundo.buscar(new Pais(paisOrigen, "", 0));
        return aux.getColor();
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(paisOrigen))
            {
             return paises[i].getColor();
            }
        }       
        return "";
    */}

    public void setTropaAPais(String pais, int tropas, String color) {  // Si se usa
  
    
        Pais pa=(Pais)mundo.buscar(new Pais(pais, "", 0));
        pa.setTropas(tropas);
        pa.setColor(color);
        if(color.compareTo(jugador.getColor())==0 && !esPaisPropio(pais))
        {
         paisesPropios.add(pa);   
        }
        if(color.compareTo(jugador.getColor())!=0 && esPaisPropio(pais))
        {
         paisesPropios.remove(pa);   
        }   

       /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().compareTo(pais)==0)
             {
                 paises[i].setTropas(tropas);
                 paises[i].setColor(color);
            }
        }*/
    }
    
    public void setTropaAPais(String pais, int tropas) {  // Si se usa
       Pais aux=(Pais)mundo.buscar(new Pais(pais, "", 0));
        aux.setTropas(tropas);/*
        
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().compareTo(pais)==0)
             {
                 paises[i].setTropas(tropas);
            }
        }*/
    }

    public void agregarEjercito(String pais) { //Si se usa
        Pais aux=(Pais)mundo.buscar(new Pais(pais, "", 0));
        aux.setTropas( aux.getTropas()+1);
        /*
        for(int i=0; i<50; i++)
        {
            if(paises[i].getNombre().equals(pais))
            {
                paises[i].setTropas( paises[i].getTropas()+1);
            }
        }*/
    }
    
    public ArrayList getArrayPaisesPropios(String color)   //Si se usa
    {

        return paisesPropios;
    }
       public ArrayList getArrayPaisesPropios()   //Si se usa
    {

           ArrayList<Pais> aux=new ArrayList();
           Iterator i=paisesPropios.iterator();
           while (i.hasNext())
           {
               Pais viejo=(Pais)i.next();
               aux.add(new Pais(viejo.getNombre(), viejo.getColor(), viejo.getTropas()));
           }
        return aux;
    }

    public void avisarAtaque(String paisOrigen, String colorDePais, int obtenerEjercitoDePais, String paisDestino, String colorDePais0, int obtenerEjercitoDePais0) {
        try {         
            salida.writeInt(17);//avisar ataque
            salida.writeUTF(paisOrigen);
            salida.writeUTF(colorDePais);
            salida.writeInt(obtenerEjercitoDePais);
            salida.writeUTF(paisDestino);
            salida.writeUTF(colorDePais0);
            salida.writeInt(obtenerEjercitoDePais0);
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void actualizarAtaque(String pais1, String color1, int ejercito1, String pais2, String color2, int ejercito2) {
        //Aca se hacen 2 cosas, se actualiza la pantalla y se actualizan los datos de los paises
        this.setTropaAPais(pais1, ejercito1, color1);
        this.setTropaAPais(pais2, ejercito2, color2);
        tablero.actualizarLabel(pais1, "/imagenes/fichas/"+color1+ejercito1+".png");
        tablero.actualizarLabel(pais2, "/imagenes/fichas/"+color2+ejercito2+".png");
    }

    public void avisarDadosAOponente(int[] dadosOrigen, int[] dadosDestino, String colorOponente) {
        try {         
            salida.writeInt(18);//avisar dados a oponente
            
            //Para verificar
            System.out.println("Envio dados:");
            System.out.println(colorOponente);
            System.out.println(dadosOrigen.length);
            
            salida.writeUTF(colorOponente);
            salida.writeInt(dadosOrigen.length);
            for (int i = 0; i < dadosOrigen.length; i++) {
                salida.writeInt(dadosOrigen[i]);
                System.out.println(dadosOrigen[i]);
            }
            
            System.out.println(dadosDestino.length);
            
            salida.writeInt(dadosDestino.length);
            for (int i = 0; i < dadosDestino.length; i++) {
                salida.writeInt(dadosDestino[i]);
                System.out.println(dadosDestino[i]);
            }
            
            
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void actualizarDadosOponente(int[] dadosOrigen, int[] dadosDestino) {
        tablero.mostrarDados(dadosDestino, dadosOrigen);
    }

    public void actualizarLabel(String pais, String direccion, int ejercito) {
        tablero.actualizarLabel(pais, direccion);
        this.setTropaAPais(pais, ejercito);
    }

    public void avisarQueGane() 
    {
        try {
            salida.writeInt(20);
            salida.writeUTF(jugador.getNombre());
            salida.writeUTF(mision.getDescripcion());
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
        
    }

    public void avisarVerificarMision() {
        try {
            salida.writeInt(19);//avisar verificar mision
        } catch (IOException ex) {
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private boolean esPaisPropio(String pais) {
        Iterator i=paisesPropios.iterator();
        boolean mio=false;
        while(i.hasNext())
        {
           Pais aux=(Pais)i.next();
           if(aux.getNombre().compareTo(pais)==0)
           {
               mio=true;
           }
        }
        return mio;
        
    }

    public void avisarVictoria(String nom, String obj) {
        if(nom.compareTo(jugador.getNombre())!=0)
        {
            tablero.avisarQuePerdi(nom, obj);
        }
    }

    public int TropasExtras() {
       int aux=0;
        if(mision.verificarAfrica(paisesPropios))
        {
            aux=aux+3;
        }
        if(mision.verificarAmericaDelNorte(paisesPropios))
        {
            aux=aux+5;
        }
        if(mision.verificarAmericaDelSur(paisesPropios))
        {
            aux=aux+3;
        }
        if(mision.verificarEuropa(paisesPropios))
        {
            aux=aux+5;
        }
        if(mision.verificarAsia(paisesPropios))
        {
            aux=aux+7;
        }
        if(mision.verificarOceania(paisesPropios))
        {
            aux=aux+2;
            
        }
        return aux;
    }
}
